(function webpackUniversalModuleDefinition(root, factory) {
  if (typeof exports === "object" && typeof module === "object")
    module.exports = factory(require("katex"));
  else if (typeof define === "function" && define.amd)
    define(["katex"], factory);
  else {
    var a =
      typeof exports === "object"
        ? factory(require("katex"))
        : factory(root["katex"]);
    for (var i in a) (typeof exports === "object" ? exports : root)[i] = a[i];
  }
})(
  typeof self !== "undefined" ? self : this,
  function (__WEBPACK_EXTERNAL_MODULE__974__) {
    return /******/ (function () {
      // webpackBootstrap
      /******/ "use strict";
      /******/ var __webpack_modules__ = {
        /***/ 974: /***/ function (module) {
          module.exports = __WEBPACK_EXTERNAL_MODULE__974__;

          /***/
        },

        /******/
      }; // The module cache
      /************************************************************************/
      /******/ /******/ var __webpack_module_cache__ = {}; // The require function
      /******/
      /******/ /******/ function __webpack_require__(moduleId) {
        /******/ // Check if module is in cache
        /******/ var cachedModule = __webpack_module_cache__[moduleId];
        /******/ if (cachedModule !== undefined) {
          /******/ return cachedModule.exports;
          /******/
        } // Create a new module (and put it into the cache)
        /******/ /******/ var module = (__webpack_module_cache__[moduleId] = {
          /******/ // no module.id needed
          /******/ // no module.loaded needed
          /******/ exports: {},
          /******/
        }); // Execute the module function
        /******/
        /******/ /******/ __webpack_modules__[moduleId](
          module,
          module.exports,
          __webpack_require__
        ); // Return the exports of the module
        /******/
        /******/ /******/ return module.exports;
        /******/
      } /* webpack/runtime/compat get default export */
      /******/
      /************************************************************************/
      /******/ /******/ !(function () {
        /******/ // getDefaultExport function for compatibility with non-harmony modules
        /******/ __webpack_require__.n = function (module) {
          /******/ var getter =
            module && module.__esModule
              ? /******/ function () {
                  return module["default"];
                }
              : /******/ function () {
                  return module;
                };
          /******/ __webpack_require__.d(getter, { a: getter });
          /******/ return getter;
          /******/
        };
        /******/
      })(); /* webpack/runtime/define property getters */
      /******/
      /******/ /******/ !(function () {
        /******/ // define getter functions for harmony exports
        /******/ __webpack_require__.d = function (exports, definition) {
          /******/ for (var key in definition) {
            /******/ if (
              __webpack_require__.o(definition, key) &&
              !__webpack_require__.o(exports, key)
            ) {
              /******/ Object.defineProperty(exports, key, {
                enumerable: true,
                get: definition[key],
              });
              /******/
            }
            /******/
          }
          /******/
        };
        /******/
      })(); /* webpack/runtime/hasOwnProperty shorthand */
      /******/
      /******/ /******/ !(function () {
        /******/ __webpack_require__.o = function (obj, prop) {
          return Object.prototype.hasOwnProperty.call(obj, prop);
        };
        /******/
      })();
      /******/
      /************************************************************************/
      var __webpack_exports__ = {};
      // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
      !(function () {
        /* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(
          974
        );
        /* harmony import */ var katex__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/ __webpack_require__.n(
          katex__WEBPACK_IMPORTED_MODULE_0__
        );
        /* eslint-disable */

        /* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */

        /* vim: set ts=2 et sw=2 tw=80: */

        /*************************************************************
         *
         *  KaTeX mhchem.js
         *
         *  This file implements a KaTeX version of mhchem version 3.3.0.
         *  It is adapted from MathJax/extensions/TeX/mhchem.js
         *  It differs from the MathJax version as follows:
         *    1. The interface is changed so that it can be called from KaTeX, not MathJax.
         *    2. \rlap and \llap are replaced with \mathrlap and \mathllap.
         *    3. Four lines of code are edited in order to use \raisebox instead of \raise.
         *    4. The reaction arrow code is simplified. All reaction arrows are rendered
         *       using KaTeX extensible arrows instead of building non-extensible arrows.
         *    5. \tripledash vertical alignment is slightly adjusted.
         *
         *    This code, as other KaTeX code, is released under the MIT license.
         *
         * /*************************************************************
         *
         *  MathJax/extensions/TeX/mhchem.js
         *
         *  Implements the \ce command for handling chemical formulas
         *  from the mhchem LaTeX package.
         *
         *  ---------------------------------------------------------------------
         *
         *  Copyright (c) 2011-2015 The MathJax Consortium
         *  Copyright (c) 2015-2018 Martin Hensel
         *
         *  Licensed under the Apache License, Version 2.0 (the "License");
         *  you may not use this file except in compliance with the License.
         *  You may obtain a copy of the License at
         *
         *      http://www.apache.org/licenses/LICENSE-2.0
         *
         *  Unless required by applicable law or agreed to in writing, software
         *  distributed under the License is distributed on an "AS IS" BASIS,
         *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
         *  See the License for the specific language governing permissions and
         *  limitations under the License.
         */
        //
        // Coding Style
        //   - use '' for identifiers that can by minified/uglified
        //   - use "" for strings that need to stay untouched
        // version: "3.3.0" for MathJax and KaTeX
        // Add \ce, \pu, and \tripledash to the KaTeX macros.
        katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro(
          "\\ce",
          function (context) {
            return chemParse(context.consumeArgs(1)[0], "ce");
          }
        );

        katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro(
          "\\pu",
          function (context) {
            return chemParse(context.consumeArgs(1)[0], "pu");
          }
        ); //  Needed for \bond for the ~ forms
        //  Raise by 2.56mu, not 2mu. We're raising a hyphen-minus, U+002D, not
        //  a mathematical minus, U+2212. So we need that extra 0.56.

        katex__WEBPACK_IMPORTED_MODULE_0___default().__defineMacro(
          "\\tripledash",
          "{\\vphantom{-}\\raisebox{2.56mu}{$\\mkern2mu" +
            "\\tiny\\text{-}\\mkern1mu\\text{-}\\mkern1mu\\text{-}\\mkern2mu$}}"
        );

        //
        //  This is the main function for handing the \ce and \pu commands.
        //  It takes the argument to \ce or \pu and returns the corresponding TeX string.
        //

        var chemParse = function chemParse(tokens, stateMachine) {
          // Recreate the argument string from KaTeX's array of tokens.
          var str = "";
          var expectedLoc = tokens[tokens.length - 1].loc.start;

          for (var i = tokens.length - 1; i >= 0; i--) {
            if (tokens[i].loc.start > expectedLoc) {
              // context.consumeArgs has eaten a space.
              str += " ";
              expectedLoc = tokens[i].loc.start;
            }

            str += tokens[i].text;
            expectedLoc += tokens[i].text.length;
          }

          var tex = texify.go(mhchemParser.go(str, stateMachine));
          return tex;
        }; //
        // Core parser for mhchem syntax  (recursive)
        //

        /** @type {MhchemParser} */

        var mhchemParser = {
          //
          // Parses mchem \ce syntax
          //
          // Call like
          //   go("H2O");
          //
          go: function go(input, stateMachine) {
            if (!input) {
              return [];
            }

            if (stateMachine === undefined) {
              stateMachine = "ce";
            }

            var state = "0"; //
            // String buffers for parsing:
            //
            // buffer.a == amount
            // buffer.o == element
            // buffer.b == left-side superscript
            // buffer.p == left-side subscript
            // buffer.q == right-side subscript
            // buffer.d == right-side superscript
            //
            // buffer.r == arrow
            // buffer.rdt == arrow, script above, type
            // buffer.rd == arrow, script above, content
            // buffer.rqt == arrow, script below, type
            // buffer.rq == arrow, script below, content
            //
            // buffer.text_
            // buffer.rm
            // etc.
            //
            // buffer.parenthesisLevel == int, starting at 0
            // buffer.sb == bool, space before
            // buffer.beginsWithBond == bool
            //
            // These letters are also used as state names.
            //
            // Other states:
            // 0 == begin of main part (arrow/operator unlikely)
            // 1 == next entity
            // 2 == next entity (arrow/operator unlikely)
            // 3 == next atom
            // c == macro
            //

            /** @type {Buffer} */

            var buffer = {};
            buffer["parenthesisLevel"] = 0;
            input = input.replace(/\n/g, " ");
            input = input.replace(/[\u2212\u2013\u2014\u2010]/g, "-");
            input = input.replace(/[\u2026]/g, "..."); //
            // Looks through mhchemParser.transitions, to execute a matching action
            // (recursive)
            //

            var lastInput;
            var watchdog = 10;
            /** @type {ParserOutput[]} */

            var output = [];

            while (true) {
              if (lastInput !== input) {
                watchdog = 10;
                lastInput = input;
              } else {
                watchdog--;
              } //
              // Find actions in transition table
              //

              var machine = mhchemParser.stateMachines[stateMachine];
              var t = machine.transitions[state] || machine.transitions["*"];

              iterateTransitions: for (var i = 0; i < t.length; i++) {
                var matches = mhchemParser.patterns.match_(t[i].pattern, input);

                if (matches) {
                  //
                  // Execute actions
                  //
                  var task = t[i].task;

                  for (var iA = 0; iA < task.action_.length; iA++) {
                    var o; //
                    // Find and execute action
                    //

                    if (machine.actions[task.action_[iA].type_]) {
                      o = machine.actions[task.action_[iA].type_](
                        buffer,
                        matches.match_,
                        task.action_[iA].option
                      );
                    } else if (mhchemParser.actions[task.action_[iA].type_]) {
                      o = mhchemParser.actions[task.action_[iA].type_](
                        buffer,
                        matches.match_,
                        task.action_[iA].option
                      );
                    } else {
                      throw [
                        "MhchemBugA",
                        "mhchem bug A. Please report. (" +
                          task.action_[iA].type_ +
                          ")",
                      ]; // Trying to use non-existing action
                    } //
                    // Add output
                    //

                    mhchemParser.concatArray(output, o);
                  } //
                  // Set next state,
                  // Shorten input,
                  // Continue with next character
                  //   (= apply only one transition per position)
                  //

                  state = task.nextState || state;

                  if (input.length > 0) {
                    if (!task.revisit) {
                      input = matches.remainder;
                    }

                    if (!task.toContinue) {
                      break iterateTransitions;
                    }
                  } else {
                    return output;
                  }
                }
              } //
              // Prevent infinite loop
              //

              if (watchdog <= 0) {
                throw ["MhchemBugU", "mhchem bug U. Please report."]; // Unexpected character
              }
            }
          },
          concatArray: function concatArray(a, b) {
            if (b) {
              if (Array.isArray(b)) {
                for (var iB = 0; iB < b.length; iB++) {
                  a.push(b[iB]);
                }
              } else {
                a.push(b);
              }
            }
          },
          patterns: {
            //
            // Matching patterns
            // either regexps or function that return null or {match_:"a", remainder:"bc"}
            //
            patterns: {
              // property names must not look like integers ("2") for correct property traversal order, later on
              empty: /^$/,
              else: /^./,
              else2: /^./,
              space: /^\s/,
              "space A": /^\s(?=[A-Z\\$])/,
              space$: /^\s$/,
              "a-z": /^[a-z]/,
              x: /^x/,
              x$: /^x$/,
              i$: /^i$/,
              letters: /^(?:[a-zA-Z\u03B1-\u03C9\u0391-\u03A9?@]|(?:\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))))+/,
              "\\greek": /^\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega|Gamma|Delta|Theta|Lambda|Xi|Pi|Sigma|Upsilon|Phi|Psi|Omega)(?:\s+|\{\}|(?![a-zA-Z]))/,
              "one lowercase latin letter $": /^(?:([a-z])(?:$|[^a-zA-Z]))$/,
              "$one lowercase latin letter$ $": /^\$(?:([a-z])(?:$|[^a-zA-Z]))\$$/,
              "one lowercase greek letter $": /^(?:\$?[\u03B1-\u03C9]\$?|\$?\\(?:alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega)\s*\$?)(?:\s+|\{\}|(?![a-zA-Z]))$/,
              digits: /^[0-9]+/,
              "-9.,9": /^[+\-]?(?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))/,
              "-9.,9 no missing 0": /^[+\-]?[0-9]+(?:[.,][0-9]+)?/,
              "(-)(9.,9)(e)(99)": function e99(input) {
                var m = input.match(
                  /^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))?(\((?:[0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+))\))?(?:([eE]|\s*(\*|x|\\times|\u00D7)\s*10\^)([+\-]?[0-9]+|\{[+\-]?[0-9]+\}))?/
                );

                if (m && m[0]) {
                  return {
                    match_: m.splice(1),
                    remainder: input.substr(m[0].length),
                  };
                }

                return null;
              },
              "(-)(9)^(-9)": function _(input) {
                var m = input.match(
                  /^(\+\-|\+\/\-|\+|\-|\\pm\s?)?([0-9]+(?:[,.][0-9]+)?|[0-9]*(?:\.[0-9]+)?)\^([+\-]?[0-9]+|\{[+\-]?[0-9]+\})/
                );

                if (m && m[0]) {
                  return {
                    match_: m.splice(1),
                    remainder: input.substr(m[0].length),
                  };
                }

                return null;
              },
              "state of aggregation $": function stateOfAggregation$(input) {
                // ... or crystal system
                var a = mhchemParser.patterns.findObserveGroups(
                  input,
                  "",
                  /^\([a-z]{1,3}(?=[\),])/,
                  ")",
                  ""
                ); // (aq), (aq,$\infty$), (aq, sat)

                if (a && a.remainder.match(/^($|[\s,;\)\]\}])/)) {
                  return a;
                } //  AND end of 'phrase'

                var m = input.match(/^(?:\((?:\\ca\s?)?\$[amothc]\$\))/); // OR crystal system ($o$) (\ca$c$)

                if (m) {
                  return {
                    match_: m[0],
                    remainder: input.substr(m[0].length),
                  };
                }

                return null;
              },
              "_{(state of aggregation)}$": /^_\{(\([a-z]{1,3}\))\}/,
              "{[(": /^(?:\\\{|\[|\()/,
              ")]}": /^(?:\)|\]|\\\})/,
              ", ": /^[,;]\s*/,
              ",": /^[,;]/,
              ".": /^[.]/,
              ". ": /^([.\u22C5\u00B7\u2022])\s*/,
              "...": /^\.\.\.(?=$|[^.])/,
              "* ": /^([*])\s*/,
              "^{(...)}": function _(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "^{",
                  "",
                  "",
                  "}"
                );
              },
              "^($...$)": function $$(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "^",
                  "$",
                  "$",
                  ""
                );
              },
              "^a": /^\^([0-9]+|[^\\_])/,
              "^\\x{}{}": function x(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "^",
                  /^\\[a-zA-Z]+\{/,
                  "}",
                  "",
                  "",
                  "{",
                  "}",
                  "",
                  true
                );
              },
              "^\\x{}": function x(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "^",
                  /^\\[a-zA-Z]+\{/,
                  "}",
                  ""
                );
              },
              "^\\x": /^\^(\\[a-zA-Z]+)\s*/,
              "^(-1)": /^\^(-?\d+)/,
              "'": /^'/,
              "_{(...)}": function _(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "_{",
                  "",
                  "",
                  "}"
                );
              },
              "_($...$)": function _$$(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "_",
                  "$",
                  "$",
                  ""
                );
              },
              _9: /^_([+\-]?[0-9]+|[^\\])/,
              "_\\x{}{}": function _X(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "_",
                  /^\\[a-zA-Z]+\{/,
                  "}",
                  "",
                  "",
                  "{",
                  "}",
                  "",
                  true
                );
              },
              "_\\x{}": function _X(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "_",
                  /^\\[a-zA-Z]+\{/,
                  "}",
                  ""
                );
              },
              "_\\x": /^_(\\[a-zA-Z]+)\s*/,
              "^_": /^(?:\^(?=_)|\_(?=\^)|[\^_]$)/,
              "{}": /^\{\}/,
              "{...}": function _(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "",
                  "{",
                  "}",
                  ""
                );
              },
              "{(...)}": function _(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "{",
                  "",
                  "",
                  "}"
                );
              },
              "$...$": function $$(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "",
                  "$",
                  "$",
                  ""
                );
              },
              "${(...)}$": function $$(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "${",
                  "",
                  "",
                  "}$"
                );
              },
              "$(...)$": function $$(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "$",
                  "",
                  "",
                  "$"
                );
              },
              "=<>": /^[=<>]/,
              "#": /^[#\u2261]/,
              "+": /^\+/,
              "-$": /^-(?=[\s_},;\]/]|$|\([a-z]+\))/,
              // -space -, -; -] -/ -$ -state-of-aggregation
              "-9": /^-(?=[0-9])/,
              "- orbital overlap": /^-(?=(?:[spd]|sp)(?:$|[\s,;\)\]\}]))/,
              "-": /^-/,
              "pm-operator": /^(?:\\pm|\$\\pm\$|\+-|\+\/-)/,
              operator: /^(?:\+|(?:[\-=<>]|<<|>>|\\approx|\$\\approx\$)(?=\s|$|-?[0-9]))/,
              arrowUpDown: /^(?:v|\(v\)|\^|\(\^\))(?=$|[\s,;\)\]\}])/,
              "\\bond{(...)}": function bond(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "\\bond{",
                  "",
                  "",
                  "}"
                );
              },
              "->": /^(?:<->|<-->|->|<-|<=>>|<<=>|<=>|[\u2192\u27F6\u21CC])/,
              CMT: /^[CMT](?=\[)/,
              "[(...)]": function _(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "[",
                  "",
                  "",
                  "]"
                );
              },
              "1st-level escape": /^(&|\\\\|\\hline)\s*/,
              "\\,": /^(?:\\[,\ ;:])/,
              // \\x - but output no space before
              "\\x{}{}": function x(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "",
                  /^\\[a-zA-Z]+\{/,
                  "}",
                  "",
                  "",
                  "{",
                  "}",
                  "",
                  true
                );
              },
              "\\x{}": function x(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "",
                  /^\\[a-zA-Z]+\{/,
                  "}",
                  ""
                );
              },
              "\\ca": /^\\ca(?:\s+|(?![a-zA-Z]))/,
              "\\x": /^(?:\\[a-zA-Z]+\s*|\\[_&{}%])/,
              orbital: /^(?:[0-9]{1,2}[spdfgh]|[0-9]{0,2}sp)(?=$|[^a-zA-Z])/,
              // only those with numbers in front, because the others will be formatted correctly anyway
              others: /^[\/~|]/,
              "\\frac{(...)}": function frac(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "\\frac{",
                  "",
                  "",
                  "}",
                  "{",
                  "",
                  "",
                  "}"
                );
              },
              "\\overset{(...)}": function overset(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "\\overset{",
                  "",
                  "",
                  "}",
                  "{",
                  "",
                  "",
                  "}"
                );
              },
              "\\underset{(...)}": function underset(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "\\underset{",
                  "",
                  "",
                  "}",
                  "{",
                  "",
                  "",
                  "}"
                );
              },
              "\\underbrace{(...)}": function underbrace(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "\\underbrace{",
                  "",
                  "",
                  "}_",
                  "{",
                  "",
                  "",
                  "}"
                );
              },
              "\\color{(...)}0": function color0(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "\\color{",
                  "",
                  "",
                  "}"
                );
              },
              "\\color{(...)}{(...)}1": function color1(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "\\color{",
                  "",
                  "",
                  "}",
                  "{",
                  "",
                  "",
                  "}"
                );
              },
              "\\color(...){(...)}2": function color2(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "\\color",
                  "\\",
                  "",
                  /^(?=\{)/,
                  "{",
                  "",
                  "",
                  "}"
                );
              },
              "\\ce{(...)}": function ce(input) {
                return mhchemParser.patterns.findObserveGroups(
                  input,
                  "\\ce{",
                  "",
                  "",
                  "}"
                );
              },
              oxidation$: /^(?:[+-][IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
              "d-oxidation$": /^(?:[+-]?\s?[IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/,
              // 0 could be oxidation or charge
              "roman numeral": /^[IVX]+/,
              "1/2$": /^[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+(?:\$[a-z]\$|[a-z])?$/,
              amount: function amount(input) {
                var match; // e.g. 2, 0.5, 1/2, -2, n/2, +;  $a$ could be added later in parsing

                match = input.match(
                  /^(?:(?:(?:\([+\-]?[0-9]+\/[0-9]+\)|[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+|[+\-]?[0-9]+[.,][0-9]+|[+\-]?\.[0-9]+|[+\-]?[0-9]+)(?:[a-z](?=\s*[A-Z]))?)|[+\-]?[a-z](?=\s*[A-Z])|\+(?!\s))/
                );

                if (match) {
                  return {
                    match_: match[0],
                    remainder: input.substr(match[0].length),
                  };
                }

                var a = mhchemParser.patterns.findObserveGroups(
                  input,
                  "",
                  "$",
                  "$",
                  ""
                );

                if (a) {
                  // e.g. $2n-1$, $-$
                  match = a.match_.match(
                    /^\$(?:\(?[+\-]?(?:[0-9]*[a-z]?[+\-])?[0-9]*[a-z](?:[+\-][0-9]*[a-z]?)?\)?|\+|-)\$$/
                  );

                  if (match) {
                    return {
                      match_: match[0],
                      remainder: input.substr(match[0].length),
                    };
                  }
                }

                return null;
              },
              amount2: function amount2(input) {
                return this["amount"](input);
              },
              "(KV letters),": /^(?:[A-Z][a-z]{0,2}|i)(?=,)/,
              formula$: function formula$(input) {
                if (input.match(/^\([a-z]+\)$/)) {
                  return null;
                } // state of aggregation = no formula

                var match = input.match(
                  /^(?:[a-z]|(?:[0-9\ \+\-\,\.\(\)]+[a-z])+[0-9\ \+\-\,\.\(\)]*|(?:[a-z][0-9\ \+\-\,\.\(\)]+)+[a-z]?)$/
                );

                if (match) {
                  return {
                    match_: match[0],
                    remainder: input.substr(match[0].length),
                  };
                }

                return null;
              },
              uprightEntities: /^(?:pH|pOH|pC|pK|iPr|iBu)(?=$|[^a-zA-Z])/,
              "/": /^\s*(\/)\s*/,
              "//": /^\s*(\/\/)\s*/,
              "*": /^\s*[*.]\s*/,
            },
            findObserveGroups: function findObserveGroups(
              input,
              begExcl,
              begIncl,
              endIncl,
              endExcl,
              beg2Excl,
              beg2Incl,
              end2Incl,
              end2Excl,
              combine
            ) {
              /** @type {{(input: string, pattern: string | RegExp): string | string[] | null;}} */
              var _match = function _match(input, pattern) {
                if (typeof pattern === "string") {
                  if (input.indexOf(pattern) !== 0) {
                    return null;
                  }

                  return pattern;
                } else {
                  var match = input.match(pattern);

                  if (!match) {
                    return null;
                  }

                  return match[0];
                }
              };
              /** @type {{(input: string, i: number, endChars: string | RegExp): {endMatchBegin: number, endMatchEnd: number} | null;}} */

              var _findObserveGroups = function _findObserveGroups(
                input,
                i,
                endChars
              ) {
                var braces = 0;

                while (i < input.length) {
                  var a = input.charAt(i);

                  var match = _match(input.substr(i), endChars);

                  if (match !== null && braces === 0) {
                    return {
                      endMatchBegin: i,
                      endMatchEnd: i + match.length,
                    };
                  } else if (a === "{") {
                    braces++;
                  } else if (a === "}") {
                    if (braces === 0) {
                      throw [
                        "ExtraCloseMissingOpen",
                        "Extra close brace or missing open brace",
                      ];
                    } else {
                      braces--;
                    }
                  }

                  i++;
                }

                if (braces > 0) {
                  return null;
                }

                return null;
              };

              var match = _match(input, begExcl);

              if (match === null) {
                return null;
              }

              input = input.substr(match.length);
              match = _match(input, begIncl);

              if (match === null) {
                return null;
              }

              var e = _findObserveGroups(
                input,
                match.length,
                endIncl || endExcl
              );

              if (e === null) {
                return null;
              }

              var match1 = input.substring(
                0,
                endIncl ? e.endMatchEnd : e.endMatchBegin
              );

              if (!(beg2Excl || beg2Incl)) {
                return {
                  match_: match1,
                  remainder: input.substr(e.endMatchEnd),
                };
              } else {
                var group2 = this.findObserveGroups(
                  input.substr(e.endMatchEnd),
                  beg2Excl,
                  beg2Incl,
                  end2Incl,
                  end2Excl
                );

                if (group2 === null) {
                  return null;
                }
                /** @type {string[]} */

                var matchRet = [match1, group2.match_];
                return {
                  match_: combine ? matchRet.join("") : matchRet,
                  remainder: group2.remainder,
                };
              }
            },
            //
            // Matching function
            // e.g. match("a", input) will look for the regexp called "a" and see if it matches
            // returns null or {match_:"a", remainder:"bc"}
            //
            match_: function match_(m, input) {
              var pattern = mhchemParser.patterns.patterns[m];

              if (pattern === undefined) {
                throw [
                  "MhchemBugP",
                  "mhchem bug P. Please report. (" + m + ")",
                ]; // Trying to use non-existing pattern
              } else if (typeof pattern === "function") {
                return mhchemParser.patterns.patterns[m](input); // cannot use cached var pattern here, because some pattern functions need this===mhchemParser
              } else {
                // RegExp
                var match = input.match(pattern);

                if (match) {
                  var mm;

                  if (match[2]) {
                    mm = [match[1], match[2]];
                  } else if (match[1]) {
                    mm = match[1];
                  } else {
                    mm = match[0];
                  }

                  return {
                    match_: mm,
                    remainder: input.substr(match[0].length),
                  };
                }

                return null;
              }
            },
          },
          //
          // Generic state machine actions
          //
          actions: {
            "a=": function a(buffer, m) {
              buffer.a = (buffer.a || "") + m;
            },
            "b=": function b(buffer, m) {
              buffer.b = (buffer.b || "") + m;
            },
            "p=": function p(buffer, m) {
              buffer.p = (buffer.p || "") + m;
            },
            "o=": function o(buffer, m) {
              buffer.o = (buffer.o || "") + m;
            },
            "q=": function q(buffer, m) {
              buffer.q = (buffer.q || "") + m;
            },
            "d=": function d(buffer, m) {
              buffer.d = (buffer.d || "") + m;
            },
            "rm=": function rm(buffer, m) {
              buffer.rm = (buffer.rm || "") + m;
            },
            "text=": function text(buffer, m) {
              buffer.text_ = (buffer.text_ || "") + m;
            },
            insert: function insert(buffer, m, a) {
              return {
                type_: a,
              };
            },
            "insert+p1": function insertP1(buffer, m, a) {
              return {
                type_: a,
                p1: m,
              };
            },
            "insert+p1+p2": function insertP1P2(buffer, m, a) {
              return {
                type_: a,
                p1: m[0],
                p2: m[1],
              };
            },
            copy: function copy(buffer, m) {
              return m;
            },
            rm: function rm(buffer, m) {
              return {
                type_: "rm",
                p1: m || "",
              };
            },
            text: function text(buffer, m) {
              return mhchemParser.go(m, "text");
            },
            "{text}": function text(buffer, m) {
              var ret = ["{"];
              mhchemParser.concatArray(ret, mhchemParser.go(m, "text"));
              ret.push("}");
              return ret;
            },
            "tex-math": function texMath(buffer, m) {
              return mhchemParser.go(m, "tex-math");
            },
            "tex-math tight": function texMathTight(buffer, m) {
              return mhchemParser.go(m, "tex-math tight");
            },
            bond: function bond(buffer, m, k) {
              return {
                type_: "bond",
                kind_: k || m,
              };
            },
            "color0-output": function color0Output(buffer, m) {
              return {
                type_: "color0",
                color: m[0],
              };
            },
            ce: function ce(buffer, m) {
              return mhchemParser.go(m);
            },
            "1/2": function _(buffer, m) {
              /** @type {ParserOutput[]} */
              var ret = [];

              if (m.match(/^[+\-]/)) {
                ret.push(m.substr(0, 1));
                m = m.substr(1);
              }

              var n = m.match(
                /^([0-9]+|\$[a-z]\$|[a-z])\/([0-9]+)(\$[a-z]\$|[a-z])?$/
              );
              n[1] = n[1].replace(/\$/g, "");
              ret.push({
                type_: "frac",
                p1: n[1],
                p2: n[2],
              });

              if (n[3]) {
                n[3] = n[3].replace(/\$/g, "");
                ret.push({
                  type_: "tex-math",
                  p1: n[3],
                });
              }

              return ret;
            },
            "9,9": function _(buffer, m) {
              return mhchemParser.go(m, "9,9");
            },
          },
          //
          // createTransitions
          // convert  { 'letter': { 'state': { action_: 'output' } } }  to  { 'state' => [ { pattern: 'letter', task: { action_: [{type_: 'output'}] } } ] }
          // with expansion of 'a|b' to 'a' and 'b' (at 2 places)
          //
          createTransitions: function createTransitions(o) {
            var pattern, state;
            /** @type {string[]} */

            var stateArray;
            var i; //
            // 1. Collect all states
            //

            /** @type {Transitions} */

            var transitions = {};

            for (pattern in o) {
              for (state in o[pattern]) {
                stateArray = state.split("|");
                o[pattern][state].stateArray = stateArray;

                for (i = 0; i < stateArray.length; i++) {
                  transitions[stateArray[i]] = [];
                }
              }
            } //
            // 2. Fill states
            //

            for (pattern in o) {
              for (state in o[pattern]) {
                stateArray = o[pattern][state].stateArray || [];

                for (i = 0; i < stateArray.length; i++) {
                  //
                  // 2a. Normalize actions into array:  'text=' ==> [{type_:'text='}]
                  // (Note to myself: Resolving the function here would be problematic. It would need .bind (for *this*) and currying (for *option*).)
                  //

                  /** @type {any} */
                  var p = o[pattern][state];

                  if (p.action_) {
                    p.action_ = [].concat(p.action_);

                    for (var k = 0; k < p.action_.length; k++) {
                      if (typeof p.action_[k] === "string") {
                        p.action_[k] = {
                          type_: p.action_[k],
                        };
                      }
                    }
                  } else {
                    p.action_ = [];
                  } //
                  // 2.b Multi-insert
                  //

                  var patternArray = pattern.split("|");

                  for (var j = 0; j < patternArray.length; j++) {
                    if (stateArray[i] === "*") {
                      // insert into all
                      for (var t in transitions) {
                        transitions[t].push({
                          pattern: patternArray[j],
                          task: p,
                        });
                      }
                    } else {
                      transitions[stateArray[i]].push({
                        pattern: patternArray[j],
                        task: p,
                      });
                    }
                  }
                }
              }
            }

            return transitions;
          },
          stateMachines: {},
        }; //
        // Definition of state machines
        //

        mhchemParser.stateMachines = {
          //
          // \ce state machines
          //
          //#region ce
          ce: {
            // main parser
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {
                  action_: "output",
                },
              },
              else: {
                "0|1|2": {
                  action_: "beginsWithBond=false",
                  revisit: true,
                  toContinue: true,
                },
              },
              oxidation$: {
                0: {
                  action_: "oxidation-output",
                },
              },
              CMT: {
                r: {
                  action_: "rdt=",
                  nextState: "rt",
                },
                rd: {
                  action_: "rqt=",
                  nextState: "rdt",
                },
              },
              arrowUpDown: {
                "0|1|2|as": {
                  action_: ["sb=false", "output", "operator"],
                  nextState: "1",
                },
              },
              uprightEntities: {
                "0|1|2": {
                  action_: ["o=", "output"],
                  nextState: "1",
                },
              },
              orbital: {
                "0|1|2|3": {
                  action_: "o=",
                  nextState: "o",
                },
              },
              "->": {
                "0|1|2|3": {
                  action_: "r=",
                  nextState: "r",
                },
                "a|as": {
                  action_: ["output", "r="],
                  nextState: "r",
                },
                "*": {
                  action_: ["output", "r="],
                  nextState: "r",
                },
              },
              "+": {
                o: {
                  action_: "d= kv",
                  nextState: "d",
                },
                "d|D": {
                  action_: "d=",
                  nextState: "d",
                },
                q: {
                  action_: "d=",
                  nextState: "qd",
                },
                "qd|qD": {
                  action_: "d=",
                  nextState: "qd",
                },
                dq: {
                  action_: ["output", "d="],
                  nextState: "d",
                },
                3: {
                  action_: ["sb=false", "output", "operator"],
                  nextState: "0",
                },
              },
              amount: {
                "0|2": {
                  action_: "a=",
                  nextState: "a",
                },
              },
              "pm-operator": {
                "0|1|2|a|as": {
                  action_: [
                    "sb=false",
                    "output",
                    {
                      type_: "operator",
                      option: "\\pm",
                    },
                  ],
                  nextState: "0",
                },
              },
              operator: {
                "0|1|2|a|as": {
                  action_: ["sb=false", "output", "operator"],
                  nextState: "0",
                },
              },
              "-$": {
                "o|q": {
                  action_: ["charge or bond", "output"],
                  nextState: "qd",
                },
                d: {
                  action_: "d=",
                  nextState: "d",
                },
                D: {
                  action_: [
                    "output",
                    {
                      type_: "bond",
                      option: "-",
                    },
                  ],
                  nextState: "3",
                },
                q: {
                  action_: "d=",
                  nextState: "qd",
                },
                qd: {
                  action_: "d=",
                  nextState: "qd",
                },
                "qD|dq": {
                  action_: [
                    "output",
                    {
                      type_: "bond",
                      option: "-",
                    },
                  ],
                  nextState: "3",
                },
              },
              "-9": {
                "3|o": {
                  action_: [
                    "output",
                    {
                      type_: "insert",
                      option: "hyphen",
                    },
                  ],
                  nextState: "3",
                },
              },
              "- orbital overlap": {
                o: {
                  action_: [
                    "output",
                    {
                      type_: "insert",
                      option: "hyphen",
                    },
                  ],
                  nextState: "2",
                },
                d: {
                  action_: [
                    "output",
                    {
                      type_: "insert",
                      option: "hyphen",
                    },
                  ],
                  nextState: "2",
                },
              },
              "-": {
                "0|1|2": {
                  action_: [
                    {
                      type_: "output",
                      option: 1,
                    },
                    "beginsWithBond=true",
                    {
                      type_: "bond",
                      option: "-",
                    },
                  ],
                  nextState: "3",
                },
                3: {
                  action_: {
                    type_: "bond",
                    option: "-",
                  },
                },
                a: {
                  action_: [
                    "output",
                    {
                      type_: "insert",
                      option: "hyphen",
                    },
                  ],
                  nextState: "2",
                },
                as: {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    {
                      type_: "bond",
                      option: "-",
                    },
                  ],
                  nextState: "3",
                },
                b: {
                  action_: "b=",
                },
                o: {
                  action_: {
                    type_: "- after o/d",
                    option: false,
                  },
                  nextState: "2",
                },
                q: {
                  action_: {
                    type_: "- after o/d",
                    option: false,
                  },
                  nextState: "2",
                },
                "d|qd|dq": {
                  action_: {
                    type_: "- after o/d",
                    option: true,
                  },
                  nextState: "2",
                },
                "D|qD|p": {
                  action_: [
                    "output",
                    {
                      type_: "bond",
                      option: "-",
                    },
                  ],
                  nextState: "3",
                },
              },
              amount2: {
                "1|3": {
                  action_: "a=",
                  nextState: "a",
                },
              },
              letters: {
                "0|1|2|3|a|as|b|p|bp|o": {
                  action_: "o=",
                  nextState: "o",
                },
                "q|dq": {
                  action_: ["output", "o="],
                  nextState: "o",
                },
                "d|D|qd|qD": {
                  action_: "o after d",
                  nextState: "o",
                },
              },
              digits: {
                o: {
                  action_: "q=",
                  nextState: "q",
                },
                "d|D": {
                  action_: "q=",
                  nextState: "dq",
                },
                q: {
                  action_: ["output", "o="],
                  nextState: "o",
                },
                a: {
                  action_: "o=",
                  nextState: "o",
                },
              },
              "space A": {
                "b|p|bp": {},
              },
              space: {
                a: {
                  nextState: "as",
                },
                0: {
                  action_: "sb=false",
                },
                "1|2": {
                  action_: "sb=true",
                },
                "r|rt|rd|rdt|rdq": {
                  action_: "output",
                  nextState: "0",
                },
                "*": {
                  action_: ["output", "sb=true"],
                  nextState: "1",
                },
              },
              "1st-level escape": {
                "1|2": {
                  action_: [
                    "output",
                    {
                      type_: "insert+p1",
                      option: "1st-level escape",
                    },
                  ],
                },
                "*": {
                  action_: [
                    "output",
                    {
                      type_: "insert+p1",
                      option: "1st-level escape",
                    },
                  ],
                  nextState: "0",
                },
              },
              "[(...)]": {
                "r|rt": {
                  action_: "rd=",
                  nextState: "rd",
                },
                "rd|rdt": {
                  action_: "rq=",
                  nextState: "rdq",
                },
              },
              "...": {
                "o|d|D|dq|qd|qD": {
                  action_: [
                    "output",
                    {
                      type_: "bond",
                      option: "...",
                    },
                  ],
                  nextState: "3",
                },
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 1,
                    },
                    {
                      type_: "insert",
                      option: "ellipsis",
                    },
                  ],
                  nextState: "1",
                },
              },
              ". |* ": {
                "*": {
                  action_: [
                    "output",
                    {
                      type_: "insert",
                      option: "addition compound",
                    },
                  ],
                  nextState: "1",
                },
              },
              "state of aggregation $": {
                "*": {
                  action_: ["output", "state of aggregation"],
                  nextState: "1",
                },
              },
              "{[(": {
                "a|as|o": {
                  action_: ["o=", "output", "parenthesisLevel++"],
                  nextState: "2",
                },
                "0|1|2|3": {
                  action_: ["o=", "output", "parenthesisLevel++"],
                  nextState: "2",
                },
                "*": {
                  action_: ["output", "o=", "output", "parenthesisLevel++"],
                  nextState: "2",
                },
              },
              ")]}": {
                "0|1|2|3|b|p|bp|o": {
                  action_: ["o=", "parenthesisLevel--"],
                  nextState: "o",
                },
                "a|as|d|D|q|qd|qD|dq": {
                  action_: ["output", "o=", "parenthesisLevel--"],
                  nextState: "o",
                },
              },
              ", ": {
                "*": {
                  action_: ["output", "comma"],
                  nextState: "0",
                },
              },
              "^_": {
                // ^ and _ without a sensible argument
                "*": {},
              },
              "^{(...)}|^($...$)": {
                "0|1|2|as": {
                  action_: "b=",
                  nextState: "b",
                },
                p: {
                  action_: "b=",
                  nextState: "bp",
                },
                "3|o": {
                  action_: "d= kv",
                  nextState: "D",
                },
                q: {
                  action_: "d=",
                  nextState: "qD",
                },
                "d|D|qd|qD|dq": {
                  action_: ["output", "d="],
                  nextState: "D",
                },
              },
              "^a|^\\x{}{}|^\\x{}|^\\x|'": {
                "0|1|2|as": {
                  action_: "b=",
                  nextState: "b",
                },
                p: {
                  action_: "b=",
                  nextState: "bp",
                },
                "3|o": {
                  action_: "d= kv",
                  nextState: "d",
                },
                q: {
                  action_: "d=",
                  nextState: "qd",
                },
                "d|qd|D|qD": {
                  action_: "d=",
                },
                dq: {
                  action_: ["output", "d="],
                  nextState: "d",
                },
              },
              "_{(state of aggregation)}$": {
                "d|D|q|qd|qD|dq": {
                  action_: ["output", "q="],
                  nextState: "q",
                },
              },
              "_{(...)}|_($...$)|_9|_\\x{}{}|_\\x{}|_\\x": {
                "0|1|2|as": {
                  action_: "p=",
                  nextState: "p",
                },
                b: {
                  action_: "p=",
                  nextState: "bp",
                },
                "3|o": {
                  action_: "q=",
                  nextState: "q",
                },
                "d|D": {
                  action_: "q=",
                  nextState: "dq",
                },
                "q|qd|qD|dq": {
                  action_: ["output", "q="],
                  nextState: "q",
                },
              },
              "=<>": {
                "0|1|2|3|a|as|o|q|d|D|qd|qD|dq": {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    "bond",
                  ],
                  nextState: "3",
                },
              },
              "#": {
                "0|1|2|3|a|as|o": {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    {
                      type_: "bond",
                      option: "#",
                    },
                  ],
                  nextState: "3",
                },
              },
              "{}": {
                "*": {
                  action_: {
                    type_: "output",
                    option: 1,
                  },
                  nextState: "1",
                },
              },
              "{...}": {
                "0|1|2|3|a|as|b|p|bp": {
                  action_: "o=",
                  nextState: "o",
                },
                "o|d|D|q|qd|qD|dq": {
                  action_: ["output", "o="],
                  nextState: "o",
                },
              },
              "$...$": {
                a: {
                  action_: "a=",
                },
                // 2$n$
                "0|1|2|3|as|b|p|bp|o": {
                  action_: "o=",
                  nextState: "o",
                },
                // not 'amount'
                "as|o": {
                  action_: "o=",
                },
                "q|d|D|qd|qD|dq": {
                  action_: ["output", "o="],
                  nextState: "o",
                },
              },
              "\\bond{(...)}": {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    "bond",
                  ],
                  nextState: "3",
                },
              },
              "\\frac{(...)}": {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 1,
                    },
                    "frac-output",
                  ],
                  nextState: "3",
                },
              },
              "\\overset{(...)}": {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    "overset-output",
                  ],
                  nextState: "3",
                },
              },
              "\\underset{(...)}": {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    "underset-output",
                  ],
                  nextState: "3",
                },
              },
              "\\underbrace{(...)}": {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    "underbrace-output",
                  ],
                  nextState: "3",
                },
              },
              "\\color{(...)}{(...)}1|\\color(...){(...)}2": {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    "color-output",
                  ],
                  nextState: "3",
                },
              },
              "\\color{(...)}0": {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    "color0-output",
                  ],
                },
              },
              "\\ce{(...)}": {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 2,
                    },
                    "ce",
                  ],
                  nextState: "3",
                },
              },
              "\\,": {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 1,
                    },
                    "copy",
                  ],
                  nextState: "1",
                },
              },
              "\\x{}{}|\\x{}|\\x": {
                "0|1|2|3|a|as|b|p|bp|o|c0": {
                  action_: ["o=", "output"],
                  nextState: "3",
                },
                "*": {
                  action_: ["output", "o=", "output"],
                  nextState: "3",
                },
              },
              others: {
                "*": {
                  action_: [
                    {
                      type_: "output",
                      option: 1,
                    },
                    "copy",
                  ],
                  nextState: "3",
                },
              },
              else2: {
                a: {
                  action_: "a to o",
                  nextState: "o",
                  revisit: true,
                },
                as: {
                  action_: ["output", "sb=true"],
                  nextState: "1",
                  revisit: true,
                },
                "r|rt|rd|rdt|rdq": {
                  action_: ["output"],
                  nextState: "0",
                  revisit: true,
                },
                "*": {
                  action_: ["output", "copy"],
                  nextState: "3",
                },
              },
            }),
            actions: {
              "o after d": function oAfterD(buffer, m) {
                var ret;

                if ((buffer.d || "").match(/^[0-9]+$/)) {
                  var tmp = buffer.d;
                  buffer.d = undefined;
                  ret = this["output"](buffer);
                  buffer.b = tmp;
                } else {
                  ret = this["output"](buffer);
                }

                mhchemParser.actions["o="](buffer, m);
                return ret;
              },
              "d= kv": function dKv(buffer, m) {
                buffer.d = m;
                buffer.dType = "kv";
              },
              "charge or bond": function chargeOrBond(buffer, m) {
                if (buffer["beginsWithBond"]) {
                  /** @type {ParserOutput[]} */
                  var ret = [];
                  mhchemParser.concatArray(ret, this["output"](buffer));
                  mhchemParser.concatArray(
                    ret,
                    mhchemParser.actions["bond"](buffer, m, "-")
                  );
                  return ret;
                } else {
                  buffer.d = m;
                }
              },
              "- after o/d": function afterOD(buffer, m, isAfterD) {
                var c1 = mhchemParser.patterns.match_(
                  "orbital",
                  buffer.o || ""
                );
                var c2 = mhchemParser.patterns.match_(
                  "one lowercase greek letter $",
                  buffer.o || ""
                );
                var c3 = mhchemParser.patterns.match_(
                  "one lowercase latin letter $",
                  buffer.o || ""
                );
                var c4 = mhchemParser.patterns.match_(
                  "$one lowercase latin letter$ $",
                  buffer.o || ""
                );
                var hyphenFollows =
                  m === "-" && ((c1 && c1.remainder === "") || c2 || c3 || c4);

                if (
                  hyphenFollows &&
                  !buffer.a &&
                  !buffer.b &&
                  !buffer.p &&
                  !buffer.d &&
                  !buffer.q &&
                  !c1 &&
                  c3
                ) {
                  buffer.o = "$" + buffer.o + "$";
                }
                /** @type {ParserOutput[]} */

                var ret = [];

                if (hyphenFollows) {
                  mhchemParser.concatArray(ret, this["output"](buffer));
                  ret.push({
                    type_: "hyphen",
                  });
                } else {
                  c1 = mhchemParser.patterns.match_("digits", buffer.d || "");

                  if (isAfterD && c1 && c1.remainder === "") {
                    mhchemParser.concatArray(
                      ret,
                      mhchemParser.actions["d="](buffer, m)
                    );
                    mhchemParser.concatArray(ret, this["output"](buffer));
                  } else {
                    mhchemParser.concatArray(ret, this["output"](buffer));
                    mhchemParser.concatArray(
                      ret,
                      mhchemParser.actions["bond"](buffer, m, "-")
                    );
                  }
                }

                return ret;
              },
              "a to o": function aToO(buffer) {
                buffer.o = buffer.a;
                buffer.a = undefined;
              },
              "sb=true": function sbTrue(buffer) {
                buffer.sb = true;
              },
              "sb=false": function sbFalse(buffer) {
                buffer.sb = false;
              },
              "beginsWithBond=true": function beginsWithBondTrue(buffer) {
                buffer["beginsWithBond"] = true;
              },
              "beginsWithBond=false": function beginsWithBondFalse(buffer) {
                buffer["beginsWithBond"] = false;
              },
              "parenthesisLevel++": function parenthesisLevel(buffer) {
                buffer["parenthesisLevel"]++;
              },
              "parenthesisLevel--": function parenthesisLevel(buffer) {
                buffer["parenthesisLevel"]--;
              },
              "state of aggregation": function stateOfAggregation(buffer, m) {
                return {
                  type_: "state of aggregation",
                  p1: mhchemParser.go(m, "o"),
                };
              },
              comma: function comma(buffer, m) {
                var a = m.replace(/\s*$/, "");
                var withSpace = a !== m;

                if (withSpace && buffer["parenthesisLevel"] === 0) {
                  return {
                    type_: "comma enumeration L",
                    p1: a,
                  };
                } else {
                  return {
                    type_: "comma enumeration M",
                    p1: a,
                  };
                }
              },
              output: function output(buffer, m, entityFollows) {
                // entityFollows:
                //   undefined = if we have nothing else to output, also ignore the just read space (buffer.sb)
                //   1 = an entity follows, never omit the space if there was one just read before (can only apply to state 1)
                //   2 = 1 + the entity can have an amount, so output a\, instead of converting it to o (can only apply to states a|as)

                /** @type {ParserOutput | ParserOutput[]} */
                var ret;

                if (!buffer.r) {
                  ret = [];

                  if (
                    !buffer.a &&
                    !buffer.b &&
                    !buffer.p &&
                    !buffer.o &&
                    !buffer.q &&
                    !buffer.d &&
                    !entityFollows
                  ) {
                    //ret = [];
                  } else {
                    if (buffer.sb) {
                      ret.push({
                        type_: "entitySkip",
                      });
                    }

                    if (
                      !buffer.o &&
                      !buffer.q &&
                      !buffer.d &&
                      !buffer.b &&
                      !buffer.p &&
                      entityFollows !== 2
                    ) {
                      buffer.o = buffer.a;
                      buffer.a = undefined;
                    } else if (
                      !buffer.o &&
                      !buffer.q &&
                      !buffer.d &&
                      (buffer.b || buffer.p)
                    ) {
                      buffer.o = buffer.a;
                      buffer.d = buffer.b;
                      buffer.q = buffer.p;
                      buffer.a = buffer.b = buffer.p = undefined;
                    } else {
                      if (
                        buffer.o &&
                        buffer.dType === "kv" &&
                        mhchemParser.patterns.match_(
                          "d-oxidation$",
                          buffer.d || ""
                        )
                      ) {
                        buffer.dType = "oxidation";
                      } else if (
                        buffer.o &&
                        buffer.dType === "kv" &&
                        !buffer.q
                      ) {
                        buffer.dType = undefined;
                      }
                    }

                    ret.push({
                      type_: "chemfive",
                      a: mhchemParser.go(buffer.a, "a"),
                      b: mhchemParser.go(buffer.b, "bd"),
                      p: mhchemParser.go(buffer.p, "pq"),
                      o: mhchemParser.go(buffer.o, "o"),
                      q: mhchemParser.go(buffer.q, "pq"),
                      d: mhchemParser.go(
                        buffer.d,
                        buffer.dType === "oxidation" ? "oxidation" : "bd"
                      ),
                      dType: buffer.dType,
                    });
                  }
                } else {
                  // r

                  /** @type {ParserOutput[]} */
                  var rd;

                  if (buffer.rdt === "M") {
                    rd = mhchemParser.go(buffer.rd, "tex-math");
                  } else if (buffer.rdt === "T") {
                    rd = [
                      {
                        type_: "text",
                        p1: buffer.rd || "",
                      },
                    ];
                  } else {
                    rd = mhchemParser.go(buffer.rd);
                  }
                  /** @type {ParserOutput[]} */

                  var rq;

                  if (buffer.rqt === "M") {
                    rq = mhchemParser.go(buffer.rq, "tex-math");
                  } else if (buffer.rqt === "T") {
                    rq = [
                      {
                        type_: "text",
                        p1: buffer.rq || "",
                      },
                    ];
                  } else {
                    rq = mhchemParser.go(buffer.rq);
                  }

                  ret = {
                    type_: "arrow",
                    r: buffer.r,
                    rd: rd,
                    rq: rq,
                  };
                }

                for (var p in buffer) {
                  if (p !== "parenthesisLevel" && p !== "beginsWithBond") {
                    delete buffer[p];
                  }
                }

                return ret;
              },
              "oxidation-output": function oxidationOutput(buffer, m) {
                var ret = ["{"];
                mhchemParser.concatArray(ret, mhchemParser.go(m, "oxidation"));
                ret.push("}");
                return ret;
              },
              "frac-output": function fracOutput(buffer, m) {
                return {
                  type_: "frac-ce",
                  p1: mhchemParser.go(m[0]),
                  p2: mhchemParser.go(m[1]),
                };
              },
              "overset-output": function oversetOutput(buffer, m) {
                return {
                  type_: "overset",
                  p1: mhchemParser.go(m[0]),
                  p2: mhchemParser.go(m[1]),
                };
              },
              "underset-output": function undersetOutput(buffer, m) {
                return {
                  type_: "underset",
                  p1: mhchemParser.go(m[0]),
                  p2: mhchemParser.go(m[1]),
                };
              },
              "underbrace-output": function underbraceOutput(buffer, m) {
                return {
                  type_: "underbrace",
                  p1: mhchemParser.go(m[0]),
                  p2: mhchemParser.go(m[1]),
                };
              },
              "color-output": function colorOutput(buffer, m) {
                return {
                  type_: "color",
                  color1: m[0],
                  color2: mhchemParser.go(m[1]),
                };
              },
              "r=": function r(buffer, m) {
                buffer.r = m;
              },
              "rdt=": function rdt(buffer, m) {
                buffer.rdt = m;
              },
              "rd=": function rd(buffer, m) {
                buffer.rd = m;
              },
              "rqt=": function rqt(buffer, m) {
                buffer.rqt = m;
              },
              "rq=": function rq(buffer, m) {
                buffer.rq = m;
              },
              operator: function operator(buffer, m, p1) {
                return {
                  type_: "operator",
                  kind_: p1 || m,
                };
              },
            },
          },
          a: {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {},
              },
              "1/2$": {
                0: {
                  action_: "1/2",
                },
              },
              else: {
                0: {
                  nextState: "1",
                  revisit: true,
                },
              },
              "$(...)$": {
                "*": {
                  action_: "tex-math tight",
                  nextState: "1",
                },
              },
              ",": {
                "*": {
                  action_: {
                    type_: "insert",
                    option: "commaDecimal",
                  },
                },
              },
              else2: {
                "*": {
                  action_: "copy",
                },
              },
            }),
            actions: {},
          },
          o: {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {},
              },
              "1/2$": {
                0: {
                  action_: "1/2",
                },
              },
              else: {
                0: {
                  nextState: "1",
                  revisit: true,
                },
              },
              letters: {
                "*": {
                  action_: "rm",
                },
              },
              "\\ca": {
                "*": {
                  action_: {
                    type_: "insert",
                    option: "circa",
                  },
                },
              },
              "\\x{}{}|\\x{}|\\x": {
                "*": {
                  action_: "copy",
                },
              },
              "${(...)}$|$(...)$": {
                "*": {
                  action_: "tex-math",
                },
              },
              "{(...)}": {
                "*": {
                  action_: "{text}",
                },
              },
              else2: {
                "*": {
                  action_: "copy",
                },
              },
            }),
            actions: {},
          },
          text: {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {
                  action_: "output",
                },
              },
              "{...}": {
                "*": {
                  action_: "text=",
                },
              },
              "${(...)}$|$(...)$": {
                "*": {
                  action_: "tex-math",
                },
              },
              "\\greek": {
                "*": {
                  action_: ["output", "rm"],
                },
              },
              "\\,|\\x{}{}|\\x{}|\\x": {
                "*": {
                  action_: ["output", "copy"],
                },
              },
              else: {
                "*": {
                  action_: "text=",
                },
              },
            }),
            actions: {
              output: function output(buffer) {
                if (buffer.text_) {
                  /** @type {ParserOutput} */
                  var ret = {
                    type_: "text",
                    p1: buffer.text_,
                  };

                  for (var p in buffer) {
                    delete buffer[p];
                  }

                  return ret;
                }
              },
            },
          },
          pq: {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {},
              },
              "state of aggregation $": {
                "*": {
                  action_: "state of aggregation",
                },
              },
              i$: {
                0: {
                  nextState: "!f",
                  revisit: true,
                },
              },
              "(KV letters),": {
                0: {
                  action_: "rm",
                  nextState: "0",
                },
              },
              formula$: {
                0: {
                  nextState: "f",
                  revisit: true,
                },
              },
              "1/2$": {
                0: {
                  action_: "1/2",
                },
              },
              else: {
                0: {
                  nextState: "!f",
                  revisit: true,
                },
              },
              "${(...)}$|$(...)$": {
                "*": {
                  action_: "tex-math",
                },
              },
              "{(...)}": {
                "*": {
                  action_: "text",
                },
              },
              "a-z": {
                f: {
                  action_: "tex-math",
                },
              },
              letters: {
                "*": {
                  action_: "rm",
                },
              },
              "-9.,9": {
                "*": {
                  action_: "9,9",
                },
              },
              ",": {
                "*": {
                  action_: {
                    type_: "insert+p1",
                    option: "comma enumeration S",
                  },
                },
              },
              "\\color{(...)}{(...)}1|\\color(...){(...)}2": {
                "*": {
                  action_: "color-output",
                },
              },
              "\\color{(...)}0": {
                "*": {
                  action_: "color0-output",
                },
              },
              "\\ce{(...)}": {
                "*": {
                  action_: "ce",
                },
              },
              "\\,|\\x{}{}|\\x{}|\\x": {
                "*": {
                  action_: "copy",
                },
              },
              else2: {
                "*": {
                  action_: "copy",
                },
              },
            }),
            actions: {
              "state of aggregation": function stateOfAggregation(buffer, m) {
                return {
                  type_: "state of aggregation subscript",
                  p1: mhchemParser.go(m, "o"),
                };
              },
              "color-output": function colorOutput(buffer, m) {
                return {
                  type_: "color",
                  color1: m[0],
                  color2: mhchemParser.go(m[1], "pq"),
                };
              },
            },
          },
          bd: {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {},
              },
              x$: {
                0: {
                  nextState: "!f",
                  revisit: true,
                },
              },
              formula$: {
                0: {
                  nextState: "f",
                  revisit: true,
                },
              },
              else: {
                0: {
                  nextState: "!f",
                  revisit: true,
                },
              },
              "-9.,9 no missing 0": {
                "*": {
                  action_: "9,9",
                },
              },
              ".": {
                "*": {
                  action_: {
                    type_: "insert",
                    option: "electron dot",
                  },
                },
              },
              "a-z": {
                f: {
                  action_: "tex-math",
                },
              },
              x: {
                "*": {
                  action_: {
                    type_: "insert",
                    option: "KV x",
                  },
                },
              },
              letters: {
                "*": {
                  action_: "rm",
                },
              },
              "'": {
                "*": {
                  action_: {
                    type_: "insert",
                    option: "prime",
                  },
                },
              },
              "${(...)}$|$(...)$": {
                "*": {
                  action_: "tex-math",
                },
              },
              "{(...)}": {
                "*": {
                  action_: "text",
                },
              },
              "\\color{(...)}{(...)}1|\\color(...){(...)}2": {
                "*": {
                  action_: "color-output",
                },
              },
              "\\color{(...)}0": {
                "*": {
                  action_: "color0-output",
                },
              },
              "\\ce{(...)}": {
                "*": {
                  action_: "ce",
                },
              },
              "\\,|\\x{}{}|\\x{}|\\x": {
                "*": {
                  action_: "copy",
                },
              },
              else2: {
                "*": {
                  action_: "copy",
                },
              },
            }),
            actions: {
              "color-output": function colorOutput(buffer, m) {
                return {
                  type_: "color",
                  color1: m[0],
                  color2: mhchemParser.go(m[1], "bd"),
                };
              },
            },
          },
          oxidation: {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {},
              },
              "roman numeral": {
                "*": {
                  action_: "roman-numeral",
                },
              },
              "${(...)}$|$(...)$": {
                "*": {
                  action_: "tex-math",
                },
              },
              else: {
                "*": {
                  action_: "copy",
                },
              },
            }),
            actions: {
              "roman-numeral": function romanNumeral(buffer, m) {
                return {
                  type_: "roman numeral",
                  p1: m || "",
                };
              },
            },
          },
          "tex-math": {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {
                  action_: "output",
                },
              },
              "\\ce{(...)}": {
                "*": {
                  action_: ["output", "ce"],
                },
              },
              "{...}|\\,|\\x{}{}|\\x{}|\\x": {
                "*": {
                  action_: "o=",
                },
              },
              else: {
                "*": {
                  action_: "o=",
                },
              },
            }),
            actions: {
              output: function output(buffer) {
                if (buffer.o) {
                  /** @type {ParserOutput} */
                  var ret = {
                    type_: "tex-math",
                    p1: buffer.o,
                  };

                  for (var p in buffer) {
                    delete buffer[p];
                  }

                  return ret;
                }
              },
            },
          },
          "tex-math tight": {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {
                  action_: "output",
                },
              },
              "\\ce{(...)}": {
                "*": {
                  action_: ["output", "ce"],
                },
              },
              "{...}|\\,|\\x{}{}|\\x{}|\\x": {
                "*": {
                  action_: "o=",
                },
              },
              "-|+": {
                "*": {
                  action_: "tight operator",
                },
              },
              else: {
                "*": {
                  action_: "o=",
                },
              },
            }),
            actions: {
              "tight operator": function tightOperator(buffer, m) {
                buffer.o = (buffer.o || "") + "{" + m + "}";
              },
              output: function output(buffer) {
                if (buffer.o) {
                  /** @type {ParserOutput} */
                  var ret = {
                    type_: "tex-math",
                    p1: buffer.o,
                  };

                  for (var p in buffer) {
                    delete buffer[p];
                  }

                  return ret;
                }
              },
            },
          },
          "9,9": {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {},
              },
              ",": {
                "*": {
                  action_: "comma",
                },
              },
              else: {
                "*": {
                  action_: "copy",
                },
              },
            }),
            actions: {
              comma: function comma() {
                return {
                  type_: "commaDecimal",
                };
              },
            },
          },
          //#endregion
          //
          // \pu state machines
          //
          //#region pu
          pu: {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {
                  action_: "output",
                },
              },
              space$: {
                "*": {
                  action_: ["output", "space"],
                },
              },
              "{[(|)]}": {
                "0|a": {
                  action_: "copy",
                },
              },
              "(-)(9)^(-9)": {
                0: {
                  action_: "number^",
                  nextState: "a",
                },
              },
              "(-)(9.,9)(e)(99)": {
                0: {
                  action_: "enumber",
                  nextState: "a",
                },
              },
              space: {
                "0|a": {},
              },
              "pm-operator": {
                "0|a": {
                  action_: {
                    type_: "operator",
                    option: "\\pm",
                  },
                  nextState: "0",
                },
              },
              operator: {
                "0|a": {
                  action_: "copy",
                  nextState: "0",
                },
              },
              "//": {
                d: {
                  action_: "o=",
                  nextState: "/",
                },
              },
              "/": {
                d: {
                  action_: "o=",
                  nextState: "/",
                },
              },
              "{...}|else": {
                "0|d": {
                  action_: "d=",
                  nextState: "d",
                },
                a: {
                  action_: ["space", "d="],
                  nextState: "d",
                },
                "/|q": {
                  action_: "q=",
                  nextState: "q",
                },
              },
            }),
            actions: {
              enumber: function enumber(buffer, m) {
                /** @type {ParserOutput[]} */
                var ret = [];

                if (m[0] === "+-" || m[0] === "+/-") {
                  ret.push("\\pm ");
                } else if (m[0]) {
                  ret.push(m[0]);
                }

                if (m[1]) {
                  mhchemParser.concatArray(
                    ret,
                    mhchemParser.go(m[1], "pu-9,9")
                  );

                  if (m[2]) {
                    if (m[2].match(/[,.]/)) {
                      mhchemParser.concatArray(
                        ret,
                        mhchemParser.go(m[2], "pu-9,9")
                      );
                    } else {
                      ret.push(m[2]);
                    }
                  }

                  m[3] = m[4] || m[3];

                  if (m[3]) {
                    m[3] = m[3].trim();

                    if (m[3] === "e" || m[3].substr(0, 1) === "*") {
                      ret.push({
                        type_: "cdot",
                      });
                    } else {
                      ret.push({
                        type_: "times",
                      });
                    }
                  }
                }

                if (m[3]) {
                  ret.push("10^{" + m[5] + "}");
                }

                return ret;
              },
              "number^": function number(buffer, m) {
                /** @type {ParserOutput[]} */
                var ret = [];

                if (m[0] === "+-" || m[0] === "+/-") {
                  ret.push("\\pm ");
                } else if (m[0]) {
                  ret.push(m[0]);
                }

                mhchemParser.concatArray(ret, mhchemParser.go(m[1], "pu-9,9"));
                ret.push("^{" + m[2] + "}");
                return ret;
              },
              operator: function operator(buffer, m, p1) {
                return {
                  type_: "operator",
                  kind_: p1 || m,
                };
              },
              space: function space() {
                return {
                  type_: "pu-space-1",
                };
              },
              output: function output(buffer) {
                /** @type {ParserOutput | ParserOutput[]} */
                var ret;
                var md = mhchemParser.patterns.match_(
                  "{(...)}",
                  buffer.d || ""
                );

                if (md && md.remainder === "") {
                  buffer.d = md.match_;
                }

                var mq = mhchemParser.patterns.match_(
                  "{(...)}",
                  buffer.q || ""
                );

                if (mq && mq.remainder === "") {
                  buffer.q = mq.match_;
                }

                if (buffer.d) {
                  buffer.d = buffer.d.replace(
                    /\u00B0C|\^oC|\^{o}C/g,
                    "{}^{\\circ}C"
                  );
                  buffer.d = buffer.d.replace(
                    /\u00B0F|\^oF|\^{o}F/g,
                    "{}^{\\circ}F"
                  );
                }

                if (buffer.q) {
                  // fraction
                  buffer.q = buffer.q.replace(
                    /\u00B0C|\^oC|\^{o}C/g,
                    "{}^{\\circ}C"
                  );
                  buffer.q = buffer.q.replace(
                    /\u00B0F|\^oF|\^{o}F/g,
                    "{}^{\\circ}F"
                  );
                  var b5 = {
                    d: mhchemParser.go(buffer.d, "pu"),
                    q: mhchemParser.go(buffer.q, "pu"),
                  };

                  if (buffer.o === "//") {
                    ret = {
                      type_: "pu-frac",
                      p1: b5.d,
                      p2: b5.q,
                    };
                  } else {
                    ret = b5.d;

                    if (b5.d.length > 1 || b5.q.length > 1) {
                      ret.push({
                        type_: " / ",
                      });
                    } else {
                      ret.push({
                        type_: "/",
                      });
                    }

                    mhchemParser.concatArray(ret, b5.q);
                  }
                } else {
                  // no fraction
                  ret = mhchemParser.go(buffer.d, "pu-2");
                }

                for (var p in buffer) {
                  delete buffer[p];
                }

                return ret;
              },
            },
          },
          "pu-2": {
            transitions: mhchemParser.createTransitions({
              empty: {
                "*": {
                  action_: "output",
                },
              },
              "*": {
                "*": {
                  action_: ["output", "cdot"],
                  nextState: "0",
                },
              },
              "\\x": {
                "*": {
                  action_: "rm=",
                },
              },
              space: {
                "*": {
                  action_: ["output", "space"],
                  nextState: "0",
                },
              },
              "^{(...)}|^(-1)": {
                1: {
                  action_: "^(-1)",
                },
              },
              "-9.,9": {
                0: {
                  action_: "rm=",
                  nextState: "0",
                },
                1: {
                  action_: "^(-1)",
                  nextState: "0",
                },
              },
              "{...}|else": {
                "*": {
                  action_: "rm=",
                  nextState: "1",
                },
              },
            }),
            actions: {
              cdot: function cdot() {
                return {
                  type_: "tight cdot",
                };
              },
              "^(-1)": function _(buffer, m) {
                buffer.rm += "^{" + m + "}";
              },
              space: function space() {
                return {
                  type_: "pu-space-2",
                };
              },
              output: function output(buffer) {
                /** @type {ParserOutput | ParserOutput[]} */
                var ret = [];

                if (buffer.rm) {
                  var mrm = mhchemParser.patterns.match_(
                    "{(...)}",
                    buffer.rm || ""
                  );

                  if (mrm && mrm.remainder === "") {
                    ret = mhchemParser.go(mrm.match_, "pu");
                  } else {
                    ret = {
                      type_: "rm",
                      p1: buffer.rm,
                    };
                  }
                }

                for (var p in buffer) {
                  delete buffer[p];
                }

                return ret;
              },
            },
          },
          "pu-9,9": {
            transitions: mhchemParser.createTransitions({
              empty: {
                0: {
                  action_: "output-0",
                },
                o: {
                  action_: "output-o",
                },
              },
              ",": {
                0: {
                  action_: ["output-0", "comma"],
                  nextState: "o",
                },
              },
              ".": {
                0: {
                  action_: ["output-0", "copy"],
                  nextState: "o",
                },
              },
              else: {
                "*": {
                  action_: "text=",
                },
              },
            }),
            actions: {
              comma: function comma() {
                return {
                  type_: "commaDecimal",
                };
              },
              "output-0": function output0(buffer) {
                /** @type {ParserOutput[]} */
                var ret = [];
                buffer.text_ = buffer.text_ || "";

                if (buffer.text_.length > 4) {
                  var a = buffer.text_.length % 3;

                  if (a === 0) {
                    a = 3;
                  }

                  for (var i = buffer.text_.length - 3; i > 0; i -= 3) {
                    ret.push(buffer.text_.substr(i, 3));
                    ret.push({
                      type_: "1000 separator",
                    });
                  }

                  ret.push(buffer.text_.substr(0, a));
                  ret.reverse();
                } else {
                  ret.push(buffer.text_);
                }

                for (var p in buffer) {
                  delete buffer[p];
                }

                return ret;
              },
              "output-o": function outputO(buffer) {
                /** @type {ParserOutput[]} */
                var ret = [];
                buffer.text_ = buffer.text_ || "";

                if (buffer.text_.length > 4) {
                  var a = buffer.text_.length - 3;

                  for (var i = 0; i < a; i += 3) {
                    ret.push(buffer.text_.substr(i, 3));
                    ret.push({
                      type_: "1000 separator",
                    });
                  }

                  ret.push(buffer.text_.substr(i));
                } else {
                  ret.push(buffer.text_);
                }

                for (var p in buffer) {
                  delete buffer[p];
                }

                return ret;
              },
            },
          }, //#endregion
        }; //
        // texify: Take MhchemParser output and convert it to TeX
        //

        /** @type {Texify} */

        var texify = {
          go: function go(input, isInner) {
            // (recursive, max 4 levels)
            if (!input) {
              return "";
            }

            var res = "";
            var cee = false;

            for (var i = 0; i < input.length; i++) {
              var inputi = input[i];

              if (typeof inputi === "string") {
                res += inputi;
              } else {
                res += texify._go2(inputi);

                if (inputi.type_ === "1st-level escape") {
                  cee = true;
                }
              }
            }

            if (!isInner && !cee && res) {
              res = "{" + res + "}";
            }

            return res;
          },
          _goInner: function _goInner(input) {
            if (!input) {
              return input;
            }

            return texify.go(input, true);
          },
          _go2: function _go2(buf) {
            /** @type {undefined | string} */
            var res;

            switch (buf.type_) {
              case "chemfive":
                res = "";
                var b5 = {
                  a: texify._goInner(buf.a),
                  b: texify._goInner(buf.b),
                  p: texify._goInner(buf.p),
                  o: texify._goInner(buf.o),
                  q: texify._goInner(buf.q),
                  d: texify._goInner(buf.d),
                }; //
                // a
                //

                if (b5.a) {
                  if (b5.a.match(/^[+\-]/)) {
                    b5.a = "{" + b5.a + "}";
                  }

                  res += b5.a + "\\,";
                } //
                // b and p
                //

                if (b5.b || b5.p) {
                  res += "{\\vphantom{X}}";
                  res +=
                    "^{\\hphantom{" +
                    (b5.b || "") +
                    "}}_{\\hphantom{" +
                    (b5.p || "") +
                    "}}";
                  res += "{\\vphantom{X}}";
                  res +=
                    "^{\\smash[t]{\\vphantom{2}}\\mathllap{" +
                    (b5.b || "") +
                    "}}";
                  res +=
                    "_{\\vphantom{2}\\mathllap{\\smash[t]{" +
                    (b5.p || "") +
                    "}}}";
                } //
                // o
                //

                if (b5.o) {
                  if (b5.o.match(/^[+\-]/)) {
                    b5.o = "{" + b5.o + "}";
                  }

                  res += b5.o;
                } //
                // q and d
                //

                if (buf.dType === "kv") {
                  if (b5.d || b5.q) {
                    res += "{\\vphantom{X}}";
                  }

                  if (b5.d) {
                    res += "^{" + b5.d + "}";
                  }

                  if (b5.q) {
                    res += "_{\\smash[t]{" + b5.q + "}}";
                  }
                } else if (buf.dType === "oxidation") {
                  if (b5.d) {
                    res += "{\\vphantom{X}}";
                    res += "^{" + b5.d + "}";
                  }

                  if (b5.q) {
                    res += "{\\vphantom{X}}";
                    res += "_{\\smash[t]{" + b5.q + "}}";
                  }
                } else {
                  if (b5.q) {
                    res += "{\\vphantom{X}}";
                    res += "_{\\smash[t]{" + b5.q + "}}";
                  }

                  if (b5.d) {
                    res += "{\\vphantom{X}}";
                    res += "^{" + b5.d + "}";
                  }
                }

                break;

              case "rm":
                res = "\\mathrm{" + buf.p1 + "}";
                break;

              case "text":
                if (buf.p1.match(/[\^_]/)) {
                  buf.p1 = buf.p1.replace(" ", "~").replace("-", "\\text{-}");
                  res = "\\mathrm{" + buf.p1 + "}";
                } else {
                  res = "\\text{" + buf.p1 + "}";
                }

                break;

              case "roman numeral":
                res = "\\mathrm{" + buf.p1 + "}";
                break;

              case "state of aggregation":
                res = "\\mskip2mu " + texify._goInner(buf.p1);
                break;

              case "state of aggregation subscript":
                res = "\\mskip1mu " + texify._goInner(buf.p1);
                break;

              case "bond":
                res = texify._getBond(buf.kind_);

                if (!res) {
                  throw [
                    "MhchemErrorBond",
                    "mhchem Error. Unknown bond type (" + buf.kind_ + ")",
                  ];
                }

                break;

              case "frac":
                var c = "\\frac{" + buf.p1 + "}{" + buf.p2 + "}";
                res =
                  "\\mathchoice{\\textstyle" +
                  c +
                  "}{" +
                  c +
                  "}{" +
                  c +
                  "}{" +
                  c +
                  "}";
                break;

              case "pu-frac":
                var d =
                  "\\frac{" +
                  texify._goInner(buf.p1) +
                  "}{" +
                  texify._goInner(buf.p2) +
                  "}";
                res =
                  "\\mathchoice{\\textstyle" +
                  d +
                  "}{" +
                  d +
                  "}{" +
                  d +
                  "}{" +
                  d +
                  "}";
                break;

              case "tex-math":
                res = buf.p1 + " ";
                break;

              case "frac-ce":
                res =
                  "\\frac{" +
                  texify._goInner(buf.p1) +
                  "}{" +
                  texify._goInner(buf.p2) +
                  "}";
                break;

              case "overset":
                res =
                  "\\overset{" +
                  texify._goInner(buf.p1) +
                  "}{" +
                  texify._goInner(buf.p2) +
                  "}";
                break;

              case "underset":
                res =
                  "\\underset{" +
                  texify._goInner(buf.p1) +
                  "}{" +
                  texify._goInner(buf.p2) +
                  "}";
                break;

              case "underbrace":
                res =
                  "\\underbrace{" +
                  texify._goInner(buf.p1) +
                  "}_{" +
                  texify._goInner(buf.p2) +
                  "}";
                break;

              case "color":
                res =
                  "{\\color{" +
                  buf.color1 +
                  "}{" +
                  texify._goInner(buf.color2) +
                  "}}";
                break;

              case "color0":
                res = "\\color{" + buf.color + "}";
                break;

              case "arrow":
                var b6 = {
                  rd: texify._goInner(buf.rd),
                  rq: texify._goInner(buf.rq),
                };

                var arrow = "\\x" + texify._getArrow(buf.r);

                if (b6.rq) {
                  arrow += "[{" + b6.rq + "}]";
                }

                if (b6.rd) {
                  arrow += "{" + b6.rd + "}";
                } else {
                  arrow += "{}";
                }

                res = arrow;
                break;

              case "operator":
                res = texify._getOperator(buf.kind_);
                break;

              case "1st-level escape":
                res = buf.p1 + " "; // &, \\\\, \\hlin

                break;

              case "space":
                res = " ";
                break;

              case "entitySkip":
                res = "~";
                break;

              case "pu-space-1":
                res = "~";
                break;

              case "pu-space-2":
                res = "\\mkern3mu ";
                break;

              case "1000 separator":
                res = "\\mkern2mu ";
                break;

              case "commaDecimal":
                res = "{,}";
                break;

              case "comma enumeration L":
                res = "{" + buf.p1 + "}\\mkern6mu ";
                break;

              case "comma enumeration M":
                res = "{" + buf.p1 + "}\\mkern3mu ";
                break;

              case "comma enumeration S":
                res = "{" + buf.p1 + "}\\mkern1mu ";
                break;

              case "hyphen":
                res = "\\text{-}";
                break;

              case "addition compound":
                res = "\\,{\\cdot}\\,";
                break;

              case "electron dot":
                res = "\\mkern1mu \\bullet\\mkern1mu ";
                break;

              case "KV x":
                res = "{\\times}";
                break;

              case "prime":
                res = "\\prime ";
                break;

              case "cdot":
                res = "\\cdot ";
                break;

              case "tight cdot":
                res = "\\mkern1mu{\\cdot}\\mkern1mu ";
                break;

              case "times":
                res = "\\times ";
                break;

              case "circa":
                res = "{\\sim}";
                break;

              case "^":
                res = "uparrow";
                break;

              case "v":
                res = "downarrow";
                break;

              case "ellipsis":
                res = "\\ldots ";
                break;

              case "/":
                res = "/";
                break;

              case " / ":
                res = "\\,/\\,";
                break;

              default:
                assertNever(buf);
                throw ["MhchemBugT", "mhchem bug T. Please report."];
              // Missing texify rule or unknown MhchemParser output
            }

            assertString(res);
            return res;
          },
          _getArrow: function _getArrow(a) {
            switch (a) {
              case "->":
                return "rightarrow";

              case "\u2192":
                return "rightarrow";

              case "\u27F6":
                return "rightarrow";

              case "<-":
                return "leftarrow";

              case "<->":
                return "leftrightarrow";

              case "<-->":
                return "rightleftarrows";

              case "<=>":
                return "rightleftharpoons";

              case "\u21CC":
                return "rightleftharpoons";

              case "<=>>":
                return "rightequilibrium";

              case "<<=>":
                return "leftequilibrium";

              default:
                assertNever(a);
                throw ["MhchemBugT", "mhchem bug T. Please report."];
            }
          },
          _getBond: function _getBond(a) {
            switch (a) {
              case "-":
                return "{-}";

              case "1":
                return "{-}";

              case "=":
                return "{=}";

              case "2":
                return "{=}";

              case "#":
                return "{\\equiv}";

              case "3":
                return "{\\equiv}";

              case "~":
                return "{\\tripledash}";

              case "~-":
                return "{\\mathrlap{\\raisebox{-.1em}{$-$}}\\raisebox{.1em}{$\\tripledash$}}";

              case "~=":
                return "{\\mathrlap{\\raisebox{-.2em}{$-$}}\\mathrlap{\\raisebox{.2em}{$\\tripledash$}}-}";

              case "~--":
                return "{\\mathrlap{\\raisebox{-.2em}{$-$}}\\mathrlap{\\raisebox{.2em}{$\\tripledash$}}-}";

              case "-~-":
                return "{\\mathrlap{\\raisebox{-.2em}{$-$}}\\mathrlap{\\raisebox{.2em}{$-$}}\\tripledash}";

              case "...":
                return "{{\\cdot}{\\cdot}{\\cdot}}";

              case "....":
                return "{{\\cdot}{\\cdot}{\\cdot}{\\cdot}}";

              case "->":
                return "{\\rightarrow}";

              case "<-":
                return "{\\leftarrow}";

              case "<":
                return "{<}";

              case ">":
                return "{>}";

              default:
                assertNever(a);
                throw ["MhchemBugT", "mhchem bug T. Please report."];
            }
          },
          _getOperator: function _getOperator(a) {
            switch (a) {
              case "+":
                return " {}+{} ";

              case "-":
                return " {}-{} ";

              case "=":
                return " {}={} ";

              case "<":
                return " {}<{} ";

              case ">":
                return " {}>{} ";

              case "<<":
                return " {}\\ll{} ";

              case ">>":
                return " {}\\gg{} ";

              case "\\pm":
                return " {}\\pm{} ";

              case "\\approx":
                return " {}\\approx{} ";

              case "$\\approx$":
                return " {}\\approx{} ";

              case "v":
                return " \\downarrow{} ";

              case "(v)":
                return " \\downarrow{} ";

              case "^":
                return " \\uparrow{} ";

              case "(^)":
                return " \\uparrow{} ";

              default:
                assertNever(a);
                throw ["MhchemBugT", "mhchem bug T. Please report."];
            }
          },
        }; //
        // Helpers for code anaylsis
        // Will show type error at calling position
        //

        /** @param {number} a */

        function assertNever(a) {}
        /** @param {string} a */

        function assertString(a) {}
      })();
      __webpack_exports__ = __webpack_exports__.default;
      /******/ return __webpack_exports__;
      /******/
    })();
  }
);
